 /*! Responsive 1.0.6
   * 2014-2015 SpryMedia Ltd - datatables.net/license
   */

/**
 * @summary     Responsive
 * @description Responsive tables plug-in for DataTables
 * @version     1.0.6
 * @file        dataTables.responsive.js
 * @author      SpryMedia Ltd (www.sprymedia.co.uk)
 * @contact     www.sprymedia.co.uk/contact
 * @copyright   Copyright 2014-2015 SpryMedia Ltd.
 *
 * This source file is free software, available under the following license:
 *   MIT license - http://datatables.net/license/mit
 *
 * This source file is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 * or FITNESS FOR A PARTICULAR PURPOSE. See the license files for details.
 *
 * For details please refer to: http://www.datatables.net
 */

(function(window, document, undefined) {


  var factory = function( $, DataTable ) {
    "use strict";

    /**
     * Responsive is a plug-in for the DataTables library that makes use of
     * DataTables' ability to change the visibility of columns, changing the
     * visibility of columns so the displayed columns fit into the table container.
     * The end result is that complex tables will be dynamically adjusted to fit
     * into the viewport, be it on a desktop, tablet or mobile browser.
     *
     * Responsive for DataTables has two modes of operation, which can used
     * individually or combined:
     *
     * * Class name based control - columns assigned class names that match the
     *   breakpoint logic can be shown / hidden as required for each breakpoint.
     * * Automatic control - columns are automatically hidden when there is no
     *   room left to display them. Columns removed from the right.
     *
     * In additional to column visibility control, Responsive also has built into
     * options to use DataTables' child row display to show / hide the information
     * from the table that has been hidden. There are also two modes of operation
     * for this child row display:
     *
     * * Inline - when the control element that the user can use to show / hide
     *   child rows is displayed inside the first column of the table.
     * * Column - where a whole column is dedicated to be the show / hide control.
     *
     * Initialisation of Responsive is performed by:
     *
     * * Adding the class `responsive` or `dt-responsive` to the table. In this case
     *   Responsive will automatically be initialised with the default configuration
     *   options when the DataTable is created.
     * * Using the `responsive` option in the DataTables configuration options. This
     *   can also be used to specify the configuration options, or simply set to
     *   `true` to use the defaults.
     *
     *  @class
     *  @param {object} settings DataTables settings object for the host table
     *  @param {object} [opts] Configuration options
     *  @requires jQuery 1.7+
     *  @requires DataTables 1.10.1+
     *
     *  @example
     *      $('#example').DataTable( {
 *        responsive: true
 *      } );
     *    } );
     */
    var Responsive = function ( settings, opts ) {
      // Sanity check that we are using DataTables 1.10 or newer
      if ( ! DataTable.versionCheck || ! DataTable.versionCheck( '1.10.1' ) ) {
        throw 'DataTables Responsive requires DataTables 1.10.1 or newer';
      }

      this.s = {
        dt: new DataTable.Api( settings ),
        columns: []
      };

      // Check if responsive has already been initialised on this table
      if ( this.s.dt.settings()[0].responsive ) {
        return;
      }

      // details is an object, but for simplicity the user can give it as a string
      if ( opts && typeof opts.details === 'string' ) {
        opts.details = { type: opts.details };
      }

      this.c = $.extend( true, {}, Responsive.defaults, DataTable.defaults.responsive, opts );
      settings.responsive = this;
      this._constructor();
    };

    Responsive.prototype = {
      /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
       * Constructor
       */

      /**
       * Initialise the Responsive instance
       *
       * @private
       */
      _constructor: function ()
      {
        var that = this;
        var dt = this.s.dt;

        dt.settings()[0]._responsive = this;

        // Use DataTables' private throttle function to avoid processor thrashing
        $(window).on( 'resize.dtr orientationchange.dtr', dt.settings()[0].oApi._fnThrottle( function () {
          that._resize();
        } ) );

        // Destroy event handler
        dt.on( 'destroy.dtr', function () {
          $(window).off( 'resize.dtr orientationchange.dtr draw.dtr' );
        } );

        // Reorder the breakpoints array here in case they have been added out
        // of order
        this.c.breakpoints.sort( function (a, b) {
          return a.width < b.width ? 1 :
            a.width > b.width ? -1 : 0;
        } );

        // Determine which columns are already hidden, and should therefore
        // remain hidden. todo - should this be done? See thread 22677
        //
        // this.s.alwaysHidden = dt.columns(':hidden').indexes();

        this._classLogic();
        this._resizeAuto();

        // Details handler
        var details = this.c.details;
        if ( details.type ) {
          that._detailsInit();
          this._detailsVis();

          dt.on( 'column-visibility.dtr', function () {
            that._detailsVis();
          } );

          // Redraw the details box on each draw. This is used until
          // DataTables implements a native `updated` event for rows
          dt.on( 'draw.dtr', function () {
            dt.rows( {page: 'current'} ).iterator( 'row', function ( settings, idx ) {
              var row = dt.row( idx );

              if ( row.child.isShown() ) {
                var info = that.c.details.renderer( dt, idx );
                row.child( info, 'child' ).show();
              }
            } );
          } );

          $(dt.table().node()).addClass( 'dtr-'+details.type );
        }

        // First pass - draw the table for the current viewport size
        this._resize();
      },


      /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
       * Private methods
       */

      /**
       * Calculate the visibility for the columns in a table for a given
       * breakpoint. The result is pre-determined based on the class logic if
       * class names are used to control all columns, but the width of the table
       * is also used if there are columns which are to be automatically shown
       * and hidden.
       *
       * @param  {string} breakpoint Breakpoint name to use for the calculation
       * @return {array} Array of boolean values initiating the visibility of each
       *   column.
       *  @private
       */
      _columnsVisiblity: function ( breakpoint )
      {
        var dt = this.s.dt;
        var columns = this.s.columns;
        var i, ien;

        // Class logic - determine which columns are in this breakpoint based
        // on the classes. If no class control (i.e. `auto`) then `-` is used
        // to indicate this to the rest of the function
        var display = $.map( columns, function ( col ) {
          return col.auto && col.minWidth === null ?
            false :
            col.auto === true ?
              '-' :
            $.inArray( breakpoint, col.includeIn ) !== -1;
        } );

        // Auto column control - first pass: how much width is taken by the
        // ones that must be included from the non-auto columns
        var requiredWidth = 0;
        for ( i=0, ien=display.length ; i<ien ; i++ ) {
          if ( display[i] === true ) {
            requiredWidth += columns[i].minWidth;
          }
        }

        // Second pass, use up any remaining width for other columns. For
        // scrolling tables we need to subtract the width of the scrollbar. It
        // may not be requires which makes this sub-optimal, but it would
        // require another full redraw to make complete use of those extra few
        // pixels
        var scrolling = dt.settings()[0].oScroll;
        var bar = scrolling.sY || scrolling.sX ? scrolling.iBarWidth : 0;
        var widthAvailable = dt.table().container().offsetWidth - bar;
        var usedWidth = widthAvailable - requiredWidth;

        // Control column needs to always be included. This makes it sub-
        // optimal in terms of using the available with, but to stop layout
        // thrashing or overflow. Also we need to account for the control column
        // width first so we know how much width is available for the other
        // columns, since the control column might not be the first one shown
        for ( i=0, ien=display.length ; i<ien ; i++ ) {
          if ( columns[i].control ) {
            usedWidth -= columns[i].minWidth;
          }
        }

        // Allow columns to be shown (counting from the left) until we run out
        // of room
        var empty = false;
        for ( i=0, ien=display.length ; i<ien ; i++ ) {
          if ( display[i] === '-' && ! columns[i].control ) {
            // Once we've found a column that won't fit we don't let any
            // others display either, or columns might disappear in the
            // middle of the table
            if ( empty || usedWidth - columns[i].minWidth < 0 ) {
              empty = true;
              display[i] = false;
            }
            else {
              display[i] = true;
            }

            usedWidth -= columns[i].minWidth;
          }
        }

        // Determine if the 'control' column should be shown (if there is one).
        // This is the case when there is a hidden column (that is not the
        // control column). The two loops look inefficient here, but they are
        // trivial and will fly through. We need to know the outcome from the
        // first , before the action in the second can be taken
        var showControl = false;

        for ( i=0, ien=columns.length ; i<ien ; i++ ) {
          if ( ! columns[i].control && ! columns[i].never && ! display[i] ) {
            showControl = true;
            break;
          }
        }

        for ( i=0, ien=columns.length ; i<ien ; i++ ) {
          if ( columns[i].control ) {
            display[i] = showControl;
          }
        }

        // Finally we need to make sure that there is at least one column that
        // is visible
        if ( $.inArray( true, display ) === -1 ) {
          display[0] = true;
        }

        return display;
      },


      /**
       * Create the internal `columns` array with information about the columns
       * for the table. This includes determining which breakpoints the column
       * will appear in, based upon class names in the column, which makes up the
       * vast majority of this method.
       *
       * @private
       */
      _classLogic: function ()
      {
        var that = this;
        var calc = {};
        var breakpoints = this.c.breakpoints;
        var columns = this.s.dt.columns().eq(0).map( function (i) {
          var className = this.column(i).header().className;

          return {
            className: className,
            includeIn: [],
            auto:      false,
            control:   false,
            never:     className.match(/\bnever\b/) ? true : false
          };
        } );

        // Simply add a breakpoint to `includeIn` array, ensuring that there are
        // no duplicates
        var add = function ( colIdx, name ) {
          var includeIn = columns[ colIdx ].includeIn;

          if ( $.inArray( name, includeIn ) === -1 ) {
            includeIn.push( name );
          }
        };

        var column = function ( colIdx, name, operator, matched ) {
          var size, i, ien;

          if ( ! operator ) {
            columns[ colIdx ].includeIn.push( name );
          }
          else if ( operator === 'max-' ) {
            // Add this breakpoint and all smaller
            size = that._find( name ).width;

            for ( i=0, ien=breakpoints.length ; i<ien ; i++ ) {
              if ( breakpoints[i].width <= size ) {
                add( colIdx, breakpoints[i].name );
              }
            }
          }
          else if ( operator === 'min-' ) {
            // Add this breakpoint and all larger
            size = that._find( name ).width;

            for ( i=0, ien=breakpoints.length ; i<ien ; i++ ) {
              if ( breakpoints[i].width >= size ) {
                add( colIdx, breakpoints[i].name );
              }
            }
          }
          else if ( operator === 'not-' ) {
            // Add all but this breakpoint (xxx need extra information)

            for ( i=0, ien=breakpoints.length ; i<ien ; i++ ) {
              if ( breakpoints[i].name.indexOf( matched ) === -1 ) {
                add( colIdx, breakpoints[i].name );
              }
            }
          }
        };

        // Loop over each column and determine if it has a responsive control
        // class
        columns.each( function ( col, i ) {
          var classNames = col.className.split(' ');
          var hasClass = false;

          // Split the class name up so multiple rules can be applied if needed
          for ( var k=0, ken=classNames.length ; k<ken ; k++ ) {
            var className = $.trim( classNames[k] );

            if ( className === 'all' ) {
              // Include in all
              hasClass = true;
              col.includeIn = $.map( breakpoints, function (a) {
                return a.name;
              } );
              return;
            }
            else if ( className === 'none' || className === 'never' ) {
              // Include in none (default) and no auto
              hasClass = true;
              return;
            }
            else if ( className === 'control' ) {
              // Special column that is only visible, when one of the other
              // columns is hidden. This is used for the details control
              hasClass = true;
              col.control = true;
              return;
            }

            $.each( breakpoints, function ( j, breakpoint ) {
              // Does this column have a class that matches this breakpoint?
              var brokenPoint = breakpoint.name.split('-');
              var re = new RegExp( '(min\\-|max\\-|not\\-)?('+brokenPoint[0]+')(\\-[_a-zA-Z0-9])?' );
              var match = className.match( re );

              if ( match ) {
                hasClass = true;

                if ( match[2] === brokenPoint[0] && match[3] === '-'+brokenPoint[1] ) {
                  // Class name matches breakpoint name fully
                  column( i, breakpoint.name, match[1], match[2]+match[3] );
                }
                else if ( match[2] === brokenPoint[0] && ! match[3] ) {
                  // Class name matched primary breakpoint name with no qualifier
                  column( i, breakpoint.name, match[1], match[2] );
                }
              }
            } );
          }

          // If there was no control class, then automatic sizing is used
          if ( ! hasClass ) {
            col.auto = true;
          }
        } );

        this.s.columns = columns;
      },


      /**
       * Initialisation for the details handler
       *
       * @private
       */
      _detailsInit: function ()
      {
        var that    = this;
        var dt      = this.s.dt;
        var details = this.c.details;

        // The inline type always uses the first child as the target
        if ( details.type === 'inline' ) {
          details.target = 'td:first-child';
        }

        // type.target can be a string jQuery selector or a column index
        var target   = details.target;
        var selector = typeof target === 'string' ? target : 'td';

        // Click handler to show / hide the details rows when they are available
        $( dt.table().body() ).on( 'click', selector, function (e) {
          // If the table is not collapsed (i.e. there is no hidden columns)
          // then take no action
          if ( ! $(dt.table().node()).hasClass('collapsed' ) ) {
            return;
          }

          // Check that the row is actually a DataTable's controlled node
          if ( ! dt.row( $(this).closest('tr') ).length ) {
            return;
          }

          // For column index, we determine if we should act or not in the
          // handler - otherwise it is already okay
          if ( typeof target === 'number' ) {
            var targetIdx = target < 0 ?
            dt.columns().eq(0).length + target :
              target;

            if ( dt.cell( this ).index().column !== targetIdx ) {
              return;
            }
          }

          // $().closest() includes itself in its check
          var row = dt.row( $(this).closest('tr') );

          if ( row.child.isShown() ) {
            row.child( false );
            $( row.node() ).removeClass( 'parent' );
          }
          else {
            var info = that.c.details.renderer( dt, row[0] );
            row.child( info, 'child' ).show();
            $( row.node() ).addClass( 'parent' );
          }
        } );
      },


      /**
       * Update the child rows in the table whenever the column visibility changes
       *
       * @private
       */
      _detailsVis: function ()
      {
        var that = this;
        var dt = this.s.dt;

        // Find how many columns are hidden
        var hiddenColumns = dt.columns().indexes().filter( function ( idx ) {
          var col = dt.column( idx );

          if ( col.visible() ) {
            return null;
          }

          // Only counts as hidden if it doesn't have the `never` class
          return $( col.header() ).hasClass( 'never' ) ? null : idx;
        } );
        var haveHidden = true;

        if ( hiddenColumns.length === 0 || ( hiddenColumns.length === 1 && this.s.columns[ hiddenColumns[0] ].control ) ) {
          haveHidden = false;
        }

        if ( haveHidden ) {
          // Show all existing child rows
          dt.rows( { page: 'current' } ).eq(0).each( function (idx) {
            var row = dt.row( idx );

            if ( row.child() ) {
              var info = that.c.details.renderer( dt, row[0] );

              // The renderer can return false to have no child row
              if ( info === false ) {
                row.child.hide();
              }
              else {
                row.child( info, 'child' ).show();
              }
            }
          } );
        }
        else {
          // Hide all existing child rows
          dt.rows( { page: 'current' } ).eq(0).each( function (idx) {
            dt.row( idx ).child.hide();
          } );
        }
      },


      /**
       * Find a breakpoint object from a name
       * @param  {string} name Breakpoint name to find
       * @return {object}      Breakpoint description object
       */
      _find: function ( name )
      {
        var breakpoints = this.c.breakpoints;

        for ( var i=0, ien=breakpoints.length ; i<ien ; i++ ) {
          if ( breakpoints[i].name === name ) {
            return breakpoints[i];
          }
        }
      },


      /**
       * Alter the table display for a resized viewport. This involves first
       * determining what breakpoint the window currently is in, getting the
       * column visibilities to apply and then setting them.
       *
       * @private
       */
      _resize: function ()
      {
        var dt = this.s.dt;
        var width = $(window).width();
        var breakpoints = this.c.breakpoints;
        var breakpoint = breakpoints[0].name;
        var columns = this.s.columns;
        var i, ien;

        // Determine what breakpoint we are currently at
        for ( i=breakpoints.length-1 ; i>=0 ; i-- ) {
          if ( width <= breakpoints[i].width ) {
            breakpoint = breakpoints[i].name;
            break;
          }
        }

        // Show the columns for that break point
        var columnsVis = this._columnsVisiblity( breakpoint );

        // Set the class before the column visibility is changed so event
        // listeners know what the state is. Need to determine if there are
        // any columns that are not visible but can be shown
        var collapsedClass = false;
        for ( i=0, ien=columns.length ; i<ien ; i++ ) {
          if ( columnsVis[i] === false && ! columns[i].never ) {
            collapsedClass = true;
            break;
          }
        }

        $( dt.table().node() ).toggleClass('collapsed', collapsedClass );

        dt.columns().eq(0).each( function ( colIdx, i ) {
          dt.column( colIdx ).visible( columnsVis[i] );
        } );
      },


      /**
       * Determine the width of each column in the table so the auto column hiding
       * has that information to work with. This method is never going to be 100%
       * perfect since column widths can change slightly per page, but without
       * seriously compromising performance this is quite effective.
       *
       * @private
       */
      _resizeAuto: function ()
      {
        var dt = this.s.dt;
        var columns = this.s.columns;

        // Are we allowed to do auto sizing?
        if ( ! this.c.auto ) {
          return;
        }

        // Are there any columns that actually need auto-sizing, or do they all
        // have classes defined
        if ( $.inArray( true, $.map( columns, function (c) { return c.auto; } ) ) === -1 ) {
          return;
        }

        // Clone the table with the current data in it
        var tableWidth   = dt.table().node().offsetWidth;
        var columnWidths = dt.columns;
        var clonedTable  = dt.table().node().cloneNode( false );
        var clonedHeader = $( dt.table().header().cloneNode( false ) ).appendTo( clonedTable );
        var clonedBody   = $( dt.table().body().cloneNode( false ) ).appendTo( clonedTable );

        $( dt.table().footer() ).clone( false ).appendTo( clonedTable );

        // This is a bit slow, but we need to get a clone of each row that
        // includes all columns. As such, try to do this as little as possible.
        dt.rows( { page: 'current' } ).indexes().flatten().each( function ( idx ) {
          var clone = dt.row( idx ).node().cloneNode( true );

          if ( dt.columns( ':hidden' ).flatten().length ) {
            $(clone).append( dt.cells( idx, ':hidden' ).nodes().to$().clone() );
          }

          $(clone).appendTo( clonedBody );
        } );

        var cells = dt.columns().header().to$().clone( false );
        $('<tr/>')
          .append( cells )
          .appendTo( clonedHeader );

        // In the inline case extra padding is applied to the first column to
        // give space for the show / hide icon. We need to use this in the
        // calculation
        if ( this.c.details.type === 'inline' ) {
          $(clonedTable).addClass( 'dtr-inline collapsed' );
        }

        var inserted = $('<div/>')
          .css( {
            width: 1,
            height: 1,
            overflow: 'hidden'
          } )
          .append( clonedTable );

        // Remove columns which are not to be included
        inserted.find('th.never, td.never').remove();

        inserted.insertBefore( dt.table().node() );

        // The cloned header now contains the smallest that each column can be
        dt.columns().eq(0).each( function ( idx ) {
          columns[idx].minWidth = cells[ idx ].offsetWidth || 0;
        } );

        inserted.remove();
      }
    };


    /**
     * List of default breakpoints. Each item in the array is an object with two
     * properties:
     *
     * * `name` - the breakpoint name.
     * * `width` - the breakpoint width
     *
     * @name Responsive.breakpoints
     * @static
     */
    Responsive.breakpoints = [
      { name: 'desktop',  width: Infinity },
      { name: 'tablet-l', width: 1024 },
      { name: 'tablet-p', width: 768 },
      { name: 'mobile-l', width: 480 },
      { name: 'mobile-p', width: 320 }
    ];


    /**
     * Responsive default settings for initialisation
     *
     * @namespace
     * @name Responsive.defaults
     * @static
     */
    Responsive.defaults = {
      /**
       * List of breakpoints for the instance. Note that this means that each
       * instance can have its own breakpoints. Additionally, the breakpoints
       * cannot be changed once an instance has been creased.
       *
       * @type {Array}
       * @default Takes the value of `Responsive.breakpoints`
       */
      breakpoints: Responsive.breakpoints,

      /**
       * Enable / disable auto hiding calculations. It can help to increase
       * performance slightly if you disable this option, but all columns would
       * need to have breakpoint classes assigned to them
       *
       * @type {Boolean}
       * @default  `true`
       */
      auto: true,

      /**
       * Details control. If given as a string value, the `type` property of the
       * default object is set to that value, and the defaults used for the rest
       * of the object - this is for ease of implementation.
       *
       * The object consists of the following properties:
       *
       * * `renderer` - function that is called for display of the child row data.
       *   The default function will show the data from the hidden columns
       * * `target` - Used as the selector for what objects to attach the child
       *   open / close to
       * * `type` - `false` to disable the details display, `inline` or `column`
       *   for the two control types
       *
       * @type {Object|string}
       */
      details: {
        renderer: function ( api, rowIdx ) {
          var data = api.cells( rowIdx, ':hidden' ).eq(0).map( function ( cell ) {
            var header = $( api.column( cell.column ).header() );
            var idx = api.cell( cell ).index();

            if ( header.hasClass( 'control' ) || header.hasClass( 'never' ) ) {
              return '';
            }

            // Use a non-public DT API method to render the data for display
            // This needs to be updated when DT adds a suitable method for
            // this type of data retrieval
            var dtPrivate = api.settings()[0];
            var cellData = dtPrivate.oApi._fnGetCellData(
              dtPrivate, idx.row, idx.column, 'display'
            );
            var title = header.text();
            if ( title ) {
              title = title + ':';
            }

            return '<li data-dtr-index="'+idx.column+'">'+
              '<span class="dtr-title">'+
              title+
              '</span> '+
              '<span class="dtr-data">'+
              cellData+
              '</span>'+
              '</li>';
          } ).toArray().join('');

          return data ?
            $('<ul data-dtr-index="'+rowIdx+'"/>').append( data ) :
            false;
        },

        target: 0,

        type: 'inline'
      }
    };


    /*
     * API
     */
    var Api = $.fn.dataTable.Api;

// Doesn't do anything - work around for a bug in DT... Not documented
    Api.register( 'responsive()', function () {
      return this;
    } );

    Api.register( 'responsive.index()', function ( li ) {
      li = $(li);

      return {
        column: li.data('dtr-index'),
        row:    li.parent().data('dtr-index')
      };
    } );

    Api.register( 'responsive.rebuild()', function () {
      return this.iterator( 'table', function ( ctx ) {
        if ( ctx._responsive ) {
          ctx._responsive._classLogic();
        }
      } );
    } );

    Api.register( 'responsive.recalc()', function () {
      return this.iterator( 'table', function ( ctx ) {
        if ( ctx._responsive ) {
          ctx._responsive._resizeAuto();
          ctx._responsive._resize();
        }
      } );
    } );


    /**
     * Version information
     *
     * @name Responsive.version
     * @static
     */
    Responsive.version = '1.0.6';


    $.fn.dataTable.Responsive = Responsive;
    $.fn.DataTable.Responsive = Responsive;

// Attach a listener to the document which listens for DataTables initialisation
// events so we can automatically initialise
    $(document).on( 'init.dt.dtr', function (e, settings, json) {
      if ( e.namespace !== 'dt' ) {
        return;
      }

      if ( $(settings.nTable).hasClass( 'responsive' ) ||
        $(settings.nTable).hasClass( 'dt-responsive' ) ||
        settings.oInit.responsive ||
        DataTable.defaults.responsive
      ) {
        var init = settings.oInit.responsive;

        if ( init !== false ) {
          new Responsive( settings, $.isPlainObject( init ) ? init : {}  );
        }
      }
    } );

    return Responsive;
  }; // /factory


// Define as an AMD module if possible
  if ( typeof define === 'function' && define.amd ) {
    define( ['jquery', 'datatables'], factory );
  }
  else if ( typeof exports === 'object' ) {
    // Node/CommonJS
    factory( require('jquery'), require('datatables') );
  }
  else if ( jQuery && !jQuery.fn.dataTable.Responsive ) {
    // Otherwise simply initialise as normal, stopping multiple evaluation
    factory( jQuery, jQuery.fn.dataTable );
  }


})(window, document);
